1
2
Næste
I de enkleste termer henter git pull en git efterfulgt af en git fusion.
Du kan til enhver tid foretage en git-hentning for at opdatere dine fjernsporingsgrene under refs / fjernbetjeninger / /.
Denne handling ændrer aldrig nogen af dine egne lokale filialer under ref / heads, og det er sikkert at gøre uden at ændre din arbejdskopi. Jeg har endda hørt om folk, der kører git-hentning med jævne mellemrum i et cron-job i baggrunden (selvom jeg ikke vil anbefale at gøre dette).
En git pull er, hvad du ville gøre for at bringe en lokal filial opdateret med sin fjernversion, samtidig med at du opdaterer dine andre filtre til fjernsporing.
Fra Git-dokumentationen til git pull:
I sin standardtilstand er git pull stenografi for git-hentning efterfulgt af git merge FETCH_HEAD.
|
Når du bruger pull, forsøger Git automatisk at udføre dit arbejde for dig. Det er kontekstafhængigt, så Git vil flette alle trukkede forpligtelser i den gren, du arbejder i. Pull fletter automatisk forpligtelserne uden at lade dig gennemgå dem først. Hvis du ikke styrer dine filialer nøje, kan du støde på hyppige konflikter.
Når du henter, samler Git alle forpligtelser fra målgrenen, der ikke findes i din nuværende gren, og gemmer dem i dit lokale arkiv. Det fusionerer dem imidlertid ikke med din nuværende filial. Dette er især nyttigt, hvis du har brug for at holde dit lager opdateret, men arbejder på noget, der kan gå i stykker, hvis du opdaterer dine filer.
For at integrere forpligtelserne i din mastergren bruger du fletning.
|
Det er vigtigt at kontrastere designfilosofien for git med filosofien om et mere traditionelt kildekontrolværktøj som SVN.
Subversion blev designet og bygget med en klient / server-model. Der er et enkelt lager, der er serveren, og flere klienter kan hente kode fra serveren, arbejde på den og derefter forpligte den tilbage til serveren. Antagelsen er, at klienten altid kan kontakte serveren, når den skal udføre en operation.
Git blev designet til at understøtte en mere distribueret model uden behov for et centralt lager (selvom du bestemt kan bruge en, hvis du vil). Også git blev designet, så klienten og "serveren" ikke behøver at være online på samme tid. Git blev designet, så folk på et upålideligt link kunne udveksle kode via e-mail, selv. Det er muligt at arbejde helt afbrudt og brænde en CD for at udveksle kode via git.
For at understøtte denne model vedligeholder git et lokalt lager med din kode og også et ekstra lokalt lager, der afspejler tilstanden for det eksterne lager. Ved at opbevare en kopi af fjernopbevaringsområdet lokalt kan git finde ud af de nødvendige ændringer, selv når det eksterne arkiv ikke kan nås. Senere, når du har brug for at sende ændringerne til en anden, kan git overføre dem som et sæt ændringer fra et tidspunkt, der er kendt til det eksterne lager.
git fetch er kommandoen, der siger "opdater min lokale kopi af fjernlageret."
git pull siger "bringe ændringerne i det eksterne lager, hvor jeg opbevarer min egen kode."
Normalt gør git pull dette ved at foretage en git-hentning for at bringe den lokale kopi af fjernlageret opdateret og derefter flette ændringerne i dit eget kodelager og muligvis din arbejdskopi.
Take away er at huske på, at der ofte er mindst tre kopier af et projekt på din arbejdsstation. En kopi er dit eget arkiv med din egen forpligtelseshistorik. Den anden kopi er din arbejdskopi, hvor du redigerer og bygger. Den tredje kopi er din lokale "cachelagrede" kopi af et eksternt lager.
|
Her er Oliver Steeles billede af, hvordan det hele passer sammen:
Hvis der er tilstrækkelig interesse, formoder jeg, at jeg kunne opdatere billedet for at tilføje git-klon og git-fletning ...
|
Et brugstilfælde med git-hentning er, at følgende vil fortælle dig eventuelle ændringer i den eksterne gren siden dit sidste træk ... så du kan kontrollere, før du laver et faktisk træk, hvilket kan ændre filer i din nuværende gren og arbejdskopi.
git-hentning
git diff ... oprindelse
Se: https://git-scm.com/docs/git-diff angående dobbelt- og tredobbelt-prikkesyntaks i diff-kommandoen
|
Det kostede mig en smule at forstå, hvad der var forskellen, men dette er en simpel forklaring. mester i din lokale vært er en gren.
Når du kloner et lager, henter du hele lageret til din lokale vært. Det betyder, at du på det tidspunkt har en oprindelses / master-markør til HEAD og master, der peger på den samme HEAD.
når du begynder at arbejde og forpligter dig, fremfører du masterpegeren til HEAD + dine forpligtelser. Men oprindelses / master-markøren peger stadig på, hvad det var, da du klonede.
Så forskellen vil være:
Hvis du foretager en git-hentning, henter den bare alle ændringer i fjernlageret (GitHub) og flytter oprindelses- / mastermarkøren til HEAD. I mellemtiden vil din lokale filialmester fortsætte med at pege på, hvor den har det.
Hvis du laver et git pull, vil det stort set hente (som tidligere forklaret) og flette eventuelle nye ændringer til dinmaster gren og flytte markøren til HEAD.
|
Nogle gange hjælper en visuel repræsentation.
|
Kort
git-hentning ligner pull, men fusionerer ikke. dvs. det henter fjernopdateringer (refs og objekter), men din lokale forbliver den samme (dvs. oprindelse / master bliver opdateret, men master forbliver den samme).
git pull trækker ned fra en fjernbetjening og smelter straks sammen.
Mere
git klon kloner en repo.
git rebase gemmer ting fra din nuværende gren, der ikke er i upstream-grenen til et midlertidigt område. Din filial er nu den samme som før du startede dine ændringer. Så git pull -rebase trækker fjernændringerne ned, spoler din lokale gren tilbage, afspiller dine ændringer over toppen af din nuværende gren en efter en, indtil du er opdateret.
Også git branch -a viser dig nøjagtigt, hvad der sker med alle dine filialer - lokalt og fjerntliggende.
Dette blogindlæg var nyttigt:
Forskellen mellem git pull, git fetch og git clone (og git rebase) - Mike Pearce
og dækker git pull, git fetch, git clone og git rebase.
====
OPDATER
Jeg troede, jeg ville opdatere dette for at vise, hvordan du faktisk ville bruge dette i praksis.
Opdater din lokale repo fra fjernbetjeningen (men flet ikke sammen):
git-hentning
Efter download af opdateringerne, lad os se forskellene:
git diff master oprindelse / master
Hvis du er tilfreds med disse opdateringer, skal du flette:
git pull
Bemærkninger:
På trin 2: For mere information om forskelle mellem lokale og fjernbetjeninger, se: Hvordan sammenligner man en lokal gitfilial med sin eksterne gren?
På trin 3: Det er sandsynligvis mere nøjagtigt (f.eks. Ved en hurtig skiftende repo) at lave en git rebase-oprindelse her. Se @Justin Ohms kommentar i et andet svar.
Se også: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Hent fra og flet sammen med et andet arkiv eller en lokal filial
SYNOPSIS
git pull ...
BESKRIVELSE
Kører git-fetch med de givne parametre og kalder git-merge for at flette
hentet hoved (e) ind i den aktuelle gren. Med --rebase, kaldes git-rebase
i stedet for git-merge.
Bemærk, at du kan bruge. (nuværende bibliotek) som den at trække
fra det lokale arkiv - dette er nyttigt, når man fletter lokale filialer
ind i den nuværende gren.
Bemærk også, at indstillinger, der er beregnet til git-pull selv og underliggende git-merge
skal gives inden de muligheder, der er beregnet til git-hentning.
Du ville trække, hvis du vil have historierne flettet, du vil hente, hvis du bare 'vil have codez', da en person har tagget nogle artikler her.
|
Du kan hente fra et eksternt lager, se forskellene og derefter trække eller flette.
Dette er et eksempel på et eksternt lager, der hedder oprindelse, og en filial kaldet master, der sporer fjerntliggende gren / oprindelse:
git checkout master
git-hentning
git diff oprindelse / master
git rebase oprindelsesmester
|
Det korte og nemme svar er, at git pull simpelthen er git-hentning efterfulgt af git merge.
Det er meget vigtigt at bemærke, at git pull automatisk flettes, uanset om du kan lide det eller ej. Dette kan naturligvis resultere i sammenlægningskonflikter. Lad os sige, at din fjernbetjening er oprindelse, og din gren er mester. Hvis du git diff origin / master inden du trækker, skal du have en idé om potentielle fusionskonflikter og kunne forberede din lokale filial i overensstemmelse hermed.
Ud over at trække og skubbe involverer nogle arbejdsgange git rebase, som denne, som jeg omskriver fra den linkede artikel:
git pull origin master
git checkout foo-gren
git rebase master
git push oprindelse foo-gren
Hvis du befinder dig i en sådan situation, kan du blive fristet til at git pull -rebase. Medmindre du virkelig, virkelig ved, hvad du laver, vil jeg fraråde det. Denne advarsel er fra mandsiden for git-pull, version 2.3.5:
Dette er en potentielt farlig driftsform. Det omskrives
historie, som ikke lover godt, når du offentliggjorde den historie
allerede. Brug ikke denne mulighed, medmindre du har læst git-rebase (1)
omhyggeligt.
|
OK, her er nogle oplysninger om git pull og git-hentning, så du kan forstå de faktiske forskelle ... i få få enkle ord får hentning de nyeste data, men ikke kodeskift og ikke kommer til at rod med din nuværende lokale filialkode , men træk for at få kodeændringerne og flette den til din lokale filial, læs videre for at få flere detaljer om hver:
git-hentning
Det downloader alle refs og objekter og eventuelle nye grene til dit lokale lager ...
Hent grene og / eller tags (samlet "refs") fra en eller flere
andre arkiver sammen med de objekter, der er nødvendige for at færdiggøre deres
historier. Eksterne sporingsgrene opdateres (se beskrivelsen
nedenfor for måder at kontrollere denne adfærd på).
Som standard er ethvert tag, der peger i historikken, der hentes,
også hentet; effekten er at hente tags, der peger på grene, der
du er interesseret i. Denne standardadfærd kan ændres ved hjælp af
indstillingerne --tags eller --no-tags eller ved at konfigurere
fjernbetjening..tagOpt. Ved at bruge en refspec, der eksplicit henter tags,
du kan hente tags, der ikke peger i grene, du er interesseret i
også ind.
git-hentning kan hente fraenten et enkelt navngivet lager eller URL, eller
fra flere arkiver på én gang, hvis det er givet, og der er et
fjernbetjeninger. indtastning i konfigurationsfilen. (Se git-config1).
Når der ikke er angivet nogen fjernbetjening, er oprindelig fjernbetjening som standard
brugt, medmindre der er en upstream-gren konfigureret til den aktuelle
afdeling.
Navnene på refs, der hentes sammen med objektnavne
de peger på, er skrevet til .git / FETCH_HEAD. Disse oplysninger kan være
bruges af scripts eller andre git-kommandoer, såsom git-pull.
git pull
Det vil anvende ændringerne fra fjernbetjening til den aktuelle filial i lokale ...
Indeholder ændringer fra et eksternt lager i den aktuelle gren.
I sin standardtilstand er git pull stenografi for git-hentning efterfulgt af
git fusion FETCH_HEAD.
Mere præcist kører git pull git-hentning med de givne parametre og
kalder git merge for at flette de hentede grenhoveder ind i strømmen
afdeling. Med --rebase kører det git rebase i stedet for git merge.
skal være navnet på et eksternt lager, som det sendes til
git-fetch1. kan navngive en vilkårlig fjernbetjening (f.eks.
navnet på et tag) eller endda en samling refs med tilsvarende
fjernsporing af grene (f.eks. refs / heads /: refs / remotes / origin /),
men normalt er det navnet på en gren i det eksterne lager.
Standardværdier for og læses fra
"fjern" og "flet" konfiguration for den aktuelle gren som angivet af
git-branch - spor.
Jeg opretter også det visuelle nedenfor for at vise dig, hvordan git-hentning og git trækker sammen ...
|
Denne interaktive grafiske gengivelse er meget nyttig til at understrege git: http://ndpsoftware.com/git-cheatsheet.html
git henter bare "downloader" ændringerne fra fjernbetjeningen til dit lokale arkiv. git pull downloader ændringerne og fletter dem ind i din nuværende filial. "I sin standardtilstand er git pull stenografi for git-hentning efterfulgt af git merge FETCH_HEAD."
|
Bonus:
Når jeg taler om pull & fetch i ovenstående svar, vil jeg gerne dele et interessant trick,
git pull - afstand
Denne ovennævnte kommando er den mest nyttige kommando i mit git-liv, som sparede en masse tid.
Inden du skubber dine nye forpligtelser til serveren, skal du prøve denne kommando, og den synkroniserer automatisk de seneste serverændringer (med en hentning + fletning) og placerer din forpligtelse øverst i git log. Ingen grund til at bekymre sig om manuel træk / fletning.
Find detaljer på: http://gitolite.com/git-pull--rebase
|
Jeg kan godt lide at have en visuel gengivelse af situationen for at forstå disse ting. Måske vil andre udviklere også gerne se det, så her er min tilføjelse. Jeg er ikke helt sikker på, at det hele er korrekt, så vær venlig at kommentere, hvis du finder fejl.
LOKALT SYSTEM
. ================================================ = ===
==================. ====================================================
FJERNBESTEMMELSE. FJERNBESTEMMELSER LOKAL OPBEVARING ARBEJDSKOPIERING
(OPRINDELSE). (CACHED)
for eksempel, . spejl af
en github repo. . ekstern repo
Kan også være.
flere repoer.
.
.
FETCH * ------------------> *
Din lokale cache på fjernbetjeningen opdateres med oprindelsen (eller flere
eksterne kilder, det er gits distribuerede natur)
.
TRÆKKE *------------------------------------------------ --------> *
ændringer flettes direkte i din lokale kopi. når der opstår konflikter,
du bliver bedt om beslutninger.
.
BEGÅ . * <--------------- *
Når du kommer fra for eksempel subversion, tror du måske, at en forpligtelse
opdaterer oprindelsen. I git udføres en forpligtelse kun over for din lokale repo.
.
PUSH * <--------------------------------------- *
Synkroniserer dine ændringer tilbage til oprindelsen.
Nogle store fordele ved at have et hentet spejl på fjernbetjeningen er:
Ydeevne (rul gennem alle forpligtelser og meddelelser uden at prøve at presse det gennem netværket)
Feedback om tilstanden for din lokale repo (for eksempel bruger jeg Atlassian's SourceTree, som giver mig en pære, der angiver, om jeg forpligter mig forud eller bagud i forhold til oprindelsen. Disse oplysninger kan opdateres med en GIT FETCH).
|
Jeg har også kæmpet med dette. Faktisk kom jeg her med en google-søgning på nøjagtigt det samme spørgsmål. Efter at have læst alle disse svar malede jeg endelig et billede i mit hoved, og jeg besluttede at prøve at få dette ned og se på tilstanden af de 2 arkiver og 1 sandkasse og handlinger, der blev udført over tid, mens jeg så versionen af dem. Så her er hvad jeg kom på. Ret mig, hvis jeg har rodet noget sted.
De tre repoer med en hentning:
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - bliver skubbet - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Lokal repo - - Lokal repo - - Lokal repo -
- træk - - - - hent -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandkasse - - Lokal sandkasse - - Lokal sandkasse -
- Kasse - - nyt arbejde udført - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
De tre repoer med et træk
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - bliver skubbet - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal repo - - Lokal repo - - Lokal repo -
- træk - - - - træk -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandkasse - - Lokal sandkasse - - Lokal sandkasse -
- Kasse - - nyt arbejde udført - - fusioneret med R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Dette hjalp mig med at forstå, hvorfor en hentning er ret vigtig.
|
Forskellen mellem GIT Fetch og GIT Pull kan forklares med følgende scenarie:
(Husk at billeder taler højere end ord !, Jeg har givet billedrepræsentation)
Lad os tage et eksempel på, at du arbejder på et projekt med dine teammedlemmer. Så der vil være en hovedgren af projektet, og alle bidragsydere skal forkaste det til deres eget lokale arkiv og derefter arbejde på denne lokale gren for at ændre / tilføje moduler og derefter skubbe tilbage til hovedgrenen.
Så,
Oprindelig tilstand for de to grene, når du forked hovedprojektet på dit lokale arkiv vil være sådan- (A, B og C er allerede moduler, der er afsluttet af projektet)
Nu er du begyndt at arbejde på det nye modul (antag D), og når du har afsluttet D-modulet, vil du skubbe det til hovedgrenen, men i mellemtiden sker der, at en af dine holdkammerater har udviklet nyt modul E, F og modificeret C.
Så hvad der er sket, er, at dit lokale lager mangler bag projektets oprindelige fremskridt, og at skubbe på dine ændringer til hovedgrenen kan føre til konflikt og kan forårsage fejl på dit modul D.
For at undgå sådanne problemer og arbejde parallelt med projektets oprindelige fremskridt er der to måder:
1. Git Fetch- Dette downloader alle de ændringer, der er foretaget i oprindelses- / hovedfilialprojektet, som ikke findes i din lokale filial. Og venter på, at kommandoen Git Merge anvender de ændringer, der er hentet i dit arkiv eller gren.
Så nu kan du omhyggeligt overvåge filerne, før du fletter det til dit arkiv. Og du kan også ændre D, hvis det er nødvendigt på grund af Modified C.
2. Git Pull- Dette opdaterer din lokale filial med oprindelsen / hovedgrenen, dvs. hvad den gør, er en kombination af Git Fetch og Git fusionere efter hinanden.
Men dette kan medføre, at der opstår konflikter, så det anbefales at bruge Git Pull med en ren kopi.
|
Vi siger simpelthen:
git pull == git fetch + git merge
Hvis du kører git pull, behøver du ikke at flette dataene til lokale. Hvis du kører git fetch, betyder det, at du skal køre git merge for at få den nyeste kode til din lokale maskine. Ellers ville den lokale maskinkode ikke blive ændret uden fletning.
Så i Git Gui, når du henter, skal du flette dataene. Hentning af sig selv foretager ikke kodeændringerne hos dit lokale. Du kan kontrollere det, når du opdaterer koden ved at hente
en gang hente og se; koden ændres ikke. Så fusionerer du ... Du vil se den ændrede kode.
|
git-hentning trækker koden ned fra fjernserveren til dine sporingsgrene i dit lokale lager. Hvis din fjernbetjening hedder oprindelse (standard), vil disse grene være inden for oprindelse /, for eksempel oprindelse / master, oprindelse / mybranch-123 osv. Disse er ikke dine nuværende grene, de er lokale kopier af disse grene fra serveren .
git pull henter en git, men fletter derefter også koden fra sporingsgrenen til din nuværendelokal version af den filial. Hvis du ikke er klar til disse ændringer endnu, skal du bare hente det først.
|
git-hentning henter fjerntliggende grene, så du kan git diff eller git flette dem med den aktuelle gren. git pull vil køre hentning på den eksterne brach sporet af den aktuelle gren og derefter flette resultatet. Du kan bruge git fetch for at se, om der er opdateringer til den eksterne filial uden nødvendigt at flette dem med din lokale filial.
|
Git Fetch
Du downloader ændringer til din lokale filial fra oprindelse til hentning. Fetch beder den eksterne repo om alle forpligtelser, som andre har foretaget, men du har ikke på din lokale repo. Fetch downloader disse forpligtelser og føjer dem til det lokale lager.
Git Merge
Du kan anvende ændringer, der er downloadet via hentning, ved hjælp af kommandoen Flet. Fletning tager forpligtelserne hentet fra hentning og forsøger at føje dem til din lokale filial. Fusionen vil beholde forpligtelseshistorikken for dine lokale ændringer, så når du deler din filial med push, vil Git vide, hvordan andre kan flette dine ændringer.
Git Pull
Hent og flet løb sammen ofte nok til, at en kommando, der kombinerer de to, pull, blev oprettet. Pull foretager en hentning og derefter en fletning for at tilføje de downloadede forpligtelser til din lokale filial.
|
Enkelt sagt, hvis du var ved at hoppe på et fly uden nogen internetforbindelse ... inden du gik af, kunne du bare gøre git-hent oprindelse . Det ville hente alle ændringerne på din computer, men holde det adskilt fra din lokale udvikling / arbejdsområde.
På flyet kan du foretage ændringer i dit lokale arbejdsområde og derefter flette det med det, du har hentet, og løse potentielle fletningskonflikter alt sammen uden forbindelse til Internettet. Og medmindre nogen havde foretaget nye ændringer i fjernopbevaringsområdet, ville du, når du ankommer til destinationen, gøre git push origin og tage din kaffe.
Fra denne fantastiske Atlassian-tutorial:
Kommandoen git fetch downloader forpligtelser, filer og refs fra en
fjernopbevaringssted i dit lokale arkiv.
Hentning er hvad du gør, når du vil se, hvad alle andre har
har arbejdet på. Det svarer til SVN-opdatering, idet det lader dig se
hvordan den centrale historie har udviklet sig, men det tvinger dig ikke til det
flet faktisk ændringerne i dit arkiv. Git isolater
hentet indhold som fra eksisterende lokalt indhold, har det absolut
ingen indflydelse på dit lokale udviklingsarbejde. Hentet indhold skal eksplicit tjekkes ud ved hjælp af kommandoen git checkout. Dette gør
at hente en sikker måde at gennemgå forpligtelser på, før de integreres med
dit lokale lager.
Når du downloader indhold fra et fjernt lager, er kommandoer til git pull og git-hentning tilgængelige til at udføre opgaven. Du kan overveje
git hent den 'sikre' version af de to kommandoer. Det downloades
fjernindholdet, men opdater ikke dit lokale arkivs arbejdstilstand,
efterlader dit nuværende arbejde intakt. git pull er jo mere aggressivt
alternativt downloader det fjernindholdet til det aktive lokale
filial og udfør straks git merge for at oprette en fusionsforpligtelse
til det nye fjernindhold. Hvis du afventer igangværende ændringer
dette vil forårsage konflikter og kickoff flådekonfliktløsning
flyde.
Med git pull:
Du får ingen isolation.
Det behøver ikke at blive eksplicit tjekket ud. Fordi det implicit fusionerer en git.
Fusionstrinet vil påvirke din lokale udvikling og kan forårsage konflikter
Det er dybest set IKKE sikkert. Det er aggressivt.
I modsætning til git-hentning, hvor det kun påvirker dine .git / refs / fjernbetjeninger, vil git pull påvirke både dine .git / refs / fjernbetjeninger og .git / refs / heads /
Hmmm ... så hvis jeg ikke opdaterer arbejdskopien med git-hentning, hvor foretager jeg ændringer? Hvor gemmer Git de nye forpligtelser?
Fantastisk spørgsmål. Det sætter det et eller andet sted isoleret fra din arbejdskopi. Men igen hvor? Lad os finde ud af det.
I din projektmappe (dvs. hvor du laver dine git-kommandoer) skal du gøre:
ls. Dette viser filer og mapper. Intet sejt, det ved jeg.
Gør nu ls -a. Dette viser prikfiler, dvs. filer der begynder med. Du kan derefter se en mappe med navnet: .git.
Gør cd .git. Dette vil naturligvis ændre din mappe.
Nu kommer den sjove del; gør ls. Du vil se en liste over mapper. Vi leder efter dommere. Gør cd-refs.
Det er interessant at se, hvad der er inde i alle mapper, men lad os fokusere på to af dem. hoveder og fjernbetjeninger. Brug cd til at kontrollere inde i dem også.
Enhver git-hentning, du foretager, opdaterer emner i /.git/refs/remotes-biblioteket. Det opdaterer ikke noget i /.git/refs/heads biblioteket.
Ethvert git-pull foretager først git-hentning, opdaterer emner i /.git/refs/remotes-biblioteket, fusionerer derefter med dit lokale og skifter derefter hovedet i /.git/refs/heads-biblioteket.
Et meget godt relateret svar kan også findes i Hvor placerer 'git henter' sig selv ?.
Se også efter "Slash notation" fra Git-filialens navngivningskonventionspost. Det hjælper dig med bedre at forstå, hvordan Git placerer ting iforskellige kataloger.
For at se den faktiske forskel
Bare gør:
git hente oprindelsesmester
git checkout master
Hvis fjernmasteren blev opdateret, får du en besked som denne:
Din filial ligger bag 'oprindelse / mester' med to forpligtelser og kan hurtigt videresendes.
(brug "git pull" for at opdatere din lokale filial)
Hvis du ikke hentede og bare git checkout master, ville din lokale git ikke vide, at der er tilføjet 2 forpligtelser. Og det ville bare sige:
Allerede på 'mester'
Din filial er opdateret med 'oprindelse / mester'.
Men det er forældet og forkert. Det er fordi git kun giver dig feedback baseret på hvad den ved. Det er uvidende om nye forpligtelser, at det endnu ikke er trukket ned ...
Er der nogen måde at se de nye ændringer, der er foretaget i fjernbetjeningen, mens du arbejder lokalt på filialen?
Nogle IDE'er (f.eks. Xcode) er superkloge og bruger resultatet af en git-hentning og kan kommentere de kodelinjer, der er blevet ændret i den eksterne gren af din nuværende arbejdsgren. Hvis denne linje er blevet ændret af både lokale ændringer og ekstern gren, bliver denne linje kommenteret med rødt. Dette er ikke en fusionskonflikt. Det er en potentiel fusionskonflikt. Det er en headsup, som du kan bruge til at løse den fremtidige fusionskonflikt, inden du gør git pull fra den eksterne gren.
Sjovt tip:
Hvis du hentede en fjernfilial f.eks. gjorde:
git hente oprindelsesfunktion / 123
Derefter ville dette gå ind i din fjernbetjeningskatalog. Det er stadig ikke tilgængeligt for dit lokale bibliotek. Det forenkler dog din checkout til den fjerntliggende gren af DWIM (gør hvad jeg mener):
git checkout-funktion / 123
du behøver ikke længere gøre:
git checkout -b funktion / 123 oprindelse / funktion / 123
Læs mere herom
|
Den eneste forskel mellem git pull og git fetch er, at:
git pull trækker fra en fjern gren og fletter den.
git henter kun henter fra den eksterne gren, men det flettes ikke
dvs. git pull = git fetch + git merge ...
|
Git tillader anvendelse af kronologisk ældre forpligtelser efter nyere forpligtelser.
På grund af dette er handlingen med overførsel af forpligtelser mellem arkiver opdelt i to trin:
Kopiering af nye forpligtelser fra fjernfilial til kopi af denne fjernfilial inden for lokal repo.
(repo til repo operation) master @ remote >> remote / origin / master @ local
Integrering af nye forpligtelser til lokal afdeling
(indvendig repo-drift) remote / origin / master @ local >> master @ local
Der er to måder at udføre trin 2. Du kan:
Gaffel lokal gren efter sidste fælles forfader, og tilføj nye forpligtelser parallelt med forpligtelser, der er unikke for lokalt arkiv, afsluttet ved at slå sammen, lukke fork.
Indsæt nye forpligtelser efter sidste fælles forfader, og anvend igen forpligtelser, der er unikke for lokalt arkiv.
I git-terminologi er trin 1 git-hentning, trin 2 er git merge eller git rebase
git pull er git fetch og git merge
|
Git opnår grenen af den nyeste version fra fjernbetjeningen til den lokale ved hjælp af to kommandoer:
git-hentning: Git får den nyeste version fra fjernbetjening til lokal, men den flettes ikke automatisk.
git hente oprindelsesmester
git log -p master..origin / master
git merge origin / master
Ovenstående kommandoer betyder, at den nyeste version af hovedgrenen downloades fra oprindelse fra hovedgrenen til fjernbetjeningen. Og sammenligner derefter den lokale mastergren og oprindelsesmastergren. Endelig flet.
git pull: Git vil hente den nyeste version fra fjernbetjeningen og fusionere med den lokale.
git pull origin master
Kommandoen ovenfor svarer til git-hentning og git-fletning. I praksis kan git hente måske mere sikkert, fordi vi inden fusionen kan se ændringerne og beslutte, om vi vil fusionere.
|
Hvad er forskellen mellem git pull og git fetch?
For at forstå dette skal du først forstå, at din lokale git ikke kun vedligeholder dit lokale lager, men det vedligeholder også en lokal kopi af det eksterne lager.
git fetch bringer din lokale kopi af fjernlageret opdateret. For eksempel, hvis dit fjernlager er GitHub - vil du muligvis hente ændringer foretaget i fjernlageret til din lokale kopi af det fjernlageret. Dette giver dig mulighed for at udføre operationer som at sammenligne eller flette.
git pull på den anden side vil bringe ændringerne i fjernlageret ned, hvor du opbevarer din egen kode. Typisk vil git pull foretage en git-hentning først for at bringe den lokale kopi af det eksterne arkiv opdateret, og derefter vil det flette ændringerne i dit eget kodelager og muligvis din arbejdskopi.
|
git pull == (git-hentning + git-fletning)
git-hentning ændres ikke til lokale filialer.
Hvis du allerede har et lokalt lager med en fjernbetjening opsat til det ønskede projekt, kan du hente alle grene og tags til den eksisterende fjernbetjening ved hjælp af git-hentning. ... Fetch foretager ingen ændringer i lokale grene, så du bliver nødt til at flette en ekstern gren med en parret lokal gren for at inkorporere ændringer, der er hentet for nylig. fra github
|
En simpel grafisk repræsentation for begyndere,
her,
git pull
henter kodefra lager og rebase med dit lokale ... i git pull er der mulighed for nye forpligtelser at blive oprettet.
men i ,
git-hentning
henter kode fra lageret, og vi skal rebase det manuelt ved hjælp af git rebase
fx: Jeg skal hente fra servermasteren og basere den igen i min lokale master.
1) git pull (rebase udføres automatisk):
git pull origin master
her oprindelse er din fjernbetjente repomester er din gren
2) git-hentning (skal rebases manuelt):
git hente oprindelsesmester
det henter serverændringer fra oprindelse. og det vil være i dit lokale, indtil du rebase det på egen hånd. vi er nødt til at løse konflikter manuelt ved at kontrollere koder.
git rebase oprindelse / master
dette vil rebase kode til lokal. inden det skal du sikre dig, at du er i den rette gren.
|
Forsøger at være klar og enkel.
Git pull-kommandoen er faktisk en genvej til git-hentning efterfulgt af git merge eller git rebase-kommandoen afhængigt af din konfiguration. Du kan konfigurere dit Git-arkiv, så git pull er en hentning efterfulgt af en rebase.
|
Faktisk vedligeholder Git en kopi af din egen kode og
fjernlageret.
Kommandoen git-hentning gør din lokale kopi opdateret ved at hente data fra det eksterne lager. Årsagen til, at vi har brug for dette, er, at en anden muligvis har foretaget nogle ændringer i koden, og du vil holde dig opdateret.
Kommandoen git pull bringer ændringerne i det eksterne lager, hvor du opbevarer din egen kode. Normalt gør git pull dette ved først at foretage en 'git-hentning' for at bringe den lokale kopi af fjernlageret opdateret, og derefter fletter det ændringerne i dit eget kodelager og muligvis din arbejdskopi.
|
1
2
Næste
Meget aktivt spørgsmål. Optjen 10 omdømme for at besvare dette spørgsmål. Omdømmekravet hjælper med at beskytte dette spørgsmål mod spam og ikke-svar-aktivitet.
Er det ikke det svar, du leder efter? Gennemse andre spørgsmål, der er tagget git version-control git-pull git-hente, eller still dit eget spørgsmål.